package collection

import (
	"fmt"
	"iter"
	"time"

	"gitee.com/gousing/helper/jsoner"
	"gitee.com/gousing/values"
)

// MapAny 便捷的Map类型数据结构（无锁, 不适用于并发场景）
type MapAny[K comparable] map[K]any

// NewMapAny 创建一个MapAny
//   - 推介字面量创建MapAny
//   - collections.MapAny{"name": "value"} 创建
func NewMapAny[K comparable](size ...uint) MapAny[K] {
	if len(size) > 0 && size[0] > 0 {
		return make(MapAny[K], size[0])
	}
	return MapAny[K]{}
}
func errMapValToType[K comparable](key K, val any, target string) error {
	return fmt.Errorf("MapAny key[%v], unable to (%#v) of type %T to %s", key, val, val, target)
}
func errMapKeyDoesNotExist[K comparable](key K) error {
	return fmt.Errorf("MapAny key[%v], does not exist", key)
}

// Set 添加键值，单层替换方式
func (s MapAny[K]) Set(name K, val any) MapAny[K] {
	s[name] = val
	return s
}

// Merge 合并map到MapAny, 单层替换方式合并
func (s MapAny[K]) Merge(data map[K]any) MapAny[K] {
	for k, v := range data {
		s[k] = v
	}
	return s
}

// Has 判断键值是否存在
func (s MapAny[K]) Has(key K) bool {
	if _, ok := s[key]; ok {
		return true
	}
	return false
}

// GetE 获取键值
func (s MapAny[K]) GetE(key K) (val any, ok bool) {
	val, ok = s[key]
	return
}

// GetOrSet 获取键值，不存在则设置
//   - 如果key不存在，则设置 k => val 并返回 val,false
//   - 如果key存在，则读取 k => val, 返回 val,true
func (s MapAny[K]) GetOrSet(key K, val any) (actual any, loaded bool) {
	if v, loaded := s[key]; loaded {
		return v, loaded
	}
	s[key] = val
	return val, false
}

// GetAndDelete 获取键值，如键值存在则同时删除
//   - 如果key存在，则读取 key => value 后删除 key, 返回 value,true
//   - 如果key不存在，则返回 nil,false
func (s MapAny[K]) GetAndDelete(key K) (value any, loaded bool) {
	if v, loaded := s[key]; loaded {
		delete(s, key)
		return v, loaded
	}
	return nil, false
}

// Delete 删除键值
func (s MapAny[K]) Delete(key K) MapAny[K] {
	delete(s, key)
	return s
}

// Int 获取Int类型键值，如键值存在且能转换为目标类型则返回，否则返回零值
func (s MapAny[K]) Int(key K) int {
	return s.IntD(key, 0)
}

// IntD 获取Int类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (s MapAny[K]) IntD(key K, defaultVal int) int {
	if v, ok := s[key]; ok {
		if val, err := values.ToIntE(v); err == nil {
			return val
		}
	}
	return defaultVal
}

// IntE 获取Int类型键值，如键值存在且能转换为目标类型则返回，否则返回零值和错误提示
func (s MapAny[K]) IntE(key K) (int, error) {
	if v, ok := s[key]; ok {
		val, err := values.ToIntE(v)
		if err == nil {
			return val, nil
		}
		return 0, errMapValToType(key, v, "int")
	}
	return 0, errMapKeyDoesNotExist(key)
}

// Uint 获取Uint类型键值，如键值存在且能转换为目标类型则返回，否则返回零值
func (s MapAny[K]) Uint(key K) uint {
	return s.UintD(key, 0)
}

// UintD 获取Uint类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (s MapAny[K]) UintD(key K, defaultVal uint) uint {
	if v, ok := s[key]; ok {
		if val, err := values.ToUintE(v); err == nil {
			return val
		}
	}
	return defaultVal
}

// UintE 获取Uint类型键值，如键值存在且能转换为目标类型则返回，否则返回零值和错误提示
func (s MapAny[K]) UintE(key K) (uint, error) {
	if v, ok := s[key]; ok {
		val, err := values.ToUintE(v)
		if err == nil {
			return val, nil
		}
		return 0, errMapValToType(key, v, "uint")
	}
	return 0, errMapKeyDoesNotExist(key)
}

// Int8 获取Int8类型键值，如键值存在且能转换为目标类型则返回，否则返回零值
func (s MapAny[K]) Int8(key K) int8 {
	return s.Int8D(key, 0)
}

// Int8D 获取Int8类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (s MapAny[K]) Int8D(key K, defaultVal int8) int8 {
	if v, ok := s[key]; ok {
		if val, err := values.ToInt8E(v); err == nil {
			return val
		}
	}
	return defaultVal
}

// Int8E 获取Int8类型键值，如键值存在且能转换为目标类型则返回，否则返回零值和错误提示
func (s MapAny[K]) Int8E(key K) (int8, error) {
	if v, ok := s[key]; ok {
		val, err := values.ToInt8E(v)
		if err == nil {
			return val, nil
		}
		return 0, errMapValToType(key, v, "int8")
	}
	return 0, errMapKeyDoesNotExist(key)
}

// Uint8 获取Uint8类型键值，如键值存在且能转换为目标类型则返回，否则返回零值
func (s MapAny[K]) Uint8(key K) uint8 {
	return s.Uint8D(key, 0)
}

// Uint8D 获取Uint8类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (s MapAny[K]) Uint8D(key K, defaultVal uint8) uint8 {
	if v, ok := s[key]; ok {
		if val, err := values.ToUint8E(v); err == nil {
			return val
		}
	}
	return defaultVal
}

// Uint8E 获取Uint8类型键值，如键值存在且能转换为目标类型则返回，否则返回零值和错误提示
func (s MapAny[K]) Uint8E(key K) (uint8, error) {
	if v, ok := s[key]; ok {
		val, err := values.ToUint8E(v)
		if err == nil {
			return val, nil
		}
		return 0, errMapValToType(key, v, "uint8")
	}
	return 0, errMapKeyDoesNotExist(key)
}

// Int16 获取Int16类型键值，如键值存在且能转换为目标类型则返回，否则返回零值
func (s MapAny[K]) Int16(key K) int16 {
	return s.Int16D(key, 0)
}

// Int16D 获取Int16类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (s MapAny[K]) Int16D(key K, defaultVal int16) int16 {
	if v, ok := s[key]; ok {
		if val, err := values.ToInt16E(v); err == nil {
			return val
		}
	}
	return defaultVal
}

// Int16E 获取Int16类型键值，如键值存在且能转换为目标类型则返回，否则返回零值和错误提示
func (s MapAny[K]) Int16E(key K) (int16, error) {
	if v, ok := s[key]; ok {
		val, err := values.ToInt16E(v)
		if err == nil {
			return val, nil
		}
		return 0, errMapValToType(key, v, "int16")
	}
	return 0, errMapKeyDoesNotExist(key)
}

// Uint16 获取Uint16类型键值，如键值存在且能转换为目标类型则返回，否则返回零值
func (s MapAny[K]) Uint16(key K) uint16 {
	return s.Uint16D(key, 0)
}

// Uint16D 获取Uint16类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (s MapAny[K]) Uint16D(key K, defaultVal uint16) uint16 {
	if v, ok := s[key]; ok {
		if val, err := values.ToUint16E(v); err == nil {
			return val
		}
	}
	return defaultVal
}

// Uint16E 获取Uint16类型键值，如键值存在且能转换为目标类型则返回，否则返回零值和错误提示
func (s MapAny[K]) Uint16E(key K) (uint16, error) {
	if v, ok := s[key]; ok {
		val, err := values.ToUint16E(v)
		if err == nil {
			return val, nil
		}
		return 0, errMapValToType(key, v, "uint16")
	}
	return 0, errMapKeyDoesNotExist(key)
}

// Int32 获取Int32类型键值，如键值存在且能转换为目标类型则返回，否则返回零值
func (s MapAny[K]) Int32(key K) int32 {
	return s.Int32D(key, 0)
}

// Int32D 获取Int32类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (s MapAny[K]) Int32D(key K, defaultVal int32) int32 {
	if v, ok := s[key]; ok {
		if val, err := values.ToInt32E(v); err == nil {
			return val
		}
	}
	return defaultVal
}

// Int32E 获取Int32类型键值，如键值存在且能转换为目标类型则返回，否则返回零值和错误提示
func (s MapAny[K]) Int32E(key K) (int32, error) {
	if v, ok := s[key]; ok {
		val, err := values.ToInt32E(v)
		if err == nil {
			return val, nil
		}
		return 0, errMapValToType(key, v, "int32")
	}
	return 0, errMapKeyDoesNotExist(key)
}

// Uint32 获取Uint32类型键值，如键值存在且能转换为目标类型则返回，否则返回零值
func (s MapAny[K]) Uint32(key K) uint32 {
	return s.Uint32D(key, 0)
}

// Uint32D 获取Uint32类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (s MapAny[K]) Uint32D(key K, defaultVal uint32) uint32 {
	if v, ok := s[key]; ok {
		if val, err := values.ToUint32E(v); err == nil {
			return val
		}
	}
	return defaultVal
}

// Uint32E 获取Uint32类型键值，如键值存在且能转换为目标类型则返回，否则返回零值和错误提示
func (s MapAny[K]) Uint32E(key K) (uint32, error) {
	if v, ok := s[key]; ok {
		val, err := values.ToUint32E(v)
		if err == nil {
			return val, nil
		}
		return 0, errMapValToType(key, v, "uint32")
	}
	return 0, errMapKeyDoesNotExist(key)
}

// Int64 获取Int64类型键值，如键值存在且能转换为目标类型则返回，否则返回零值
func (s MapAny[K]) Int64(key K) int64 {
	return s.Int64D(key, 0)
}

// Int64D 获取Int64类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (s MapAny[K]) Int64D(key K, defaultVal int64) int64 {
	if v, ok := s[key]; ok {
		if val, err := values.ToInt64E(v); err == nil {
			return val
		}
	}
	return defaultVal
}

// Int64E 获取Int64类型键值，如键值存在且能转换为目标类型则返回，否则返回零值和错误提示
func (s MapAny[K]) Int64E(key K) (int64, error) {
	if v, ok := s[key]; ok {
		val, err := values.ToInt64E(v)
		if err == nil {
			return val, nil
		}
		return 0, errMapValToType(key, v, "int64")
	}
	return 0, errMapKeyDoesNotExist(key)
}

// Uint64 获取Uint64类型键值，如键值存在且能转换为目标类型则返回，否则返回零值
func (s MapAny[K]) Uint64(key K) uint64 {
	return s.Uint64D(key, 0)
}

// Uint64D 获取Uint64类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (s MapAny[K]) Uint64D(key K, defaultVal uint64) uint64 {
	if v, ok := s[key]; ok {
		if val, err := values.ToUint64E(v); err == nil {
			return val
		}
	}
	return defaultVal
}

// Uint64E 获取Uint64类型键值，如键值存在且能转换为目标类型则返回，否则返回零值和错误提示
func (s MapAny[K]) Uint64E(key K) (uint64, error) {
	if v, ok := s[key]; ok {
		val, err := values.ToUint64E(v)
		if err == nil {
			return val, nil
		}
		return 0, errMapValToType(key, v, "uint64")
	}
	return 0, errMapKeyDoesNotExist(key)
}

// Float32 获取Float32类型键值，如键值存在且能转换为目标类型则返回，否则返回零值
func (s MapAny[K]) Float32(key K) float32 {
	return s.Float32D(key, 0)
}

// Float32D 获取Float32类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (s MapAny[K]) Float32D(key K, defaultVal float32) float32 {
	if v, ok := s[key]; ok {
		if val, err := values.ToFloat32E(v); err == nil {
			return val
		}
	}
	return defaultVal
}

// Float32E 获取Float32类型键值，如键值存在且能转换为目标类型则返回，否则返回零值和错误提示
func (s MapAny[K]) Float32E(key K) (float32, error) {
	if v, ok := s[key]; ok {
		val, err := values.ToFloat32E(v)
		if err == nil {
			return val, nil
		}
		return 0, errMapValToType(key, v, "float32")
	}
	return 0, errMapKeyDoesNotExist(key)
}

// Float64 获取Float64类型键值，如键值存在且能转换为目标类型则返回，否则返回零值
func (s MapAny[K]) Float64(key K) float64 {
	return s.Float64D(key, 0)
}

// Float64D 获取Float64类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (s MapAny[K]) Float64D(key K, defaultVal float64) float64 {
	if v, ok := s[key]; ok {
		if val, err := values.ToFloat64E(v); err == nil {
			return val
		}
	}
	return defaultVal
}

// Float64E 获取Float64类型键值，如键值存在且能转换为目标类型则返回，否则返回零值和错误提示
func (s MapAny[K]) Float64E(key K) (float64, error) {
	if v, ok := s[key]; ok {
		val, err := values.ToFloat64E(v)
		if err == nil {
			return val, nil
		}
		return 0, errMapValToType(key, v, "float64")
	}
	return 0, errMapKeyDoesNotExist(key)
}

// String 获取String类型键值，如键值存在且能转换为目标类型则返回，否则返回零值
func (s MapAny[K]) String(name K) string {
	return s.StringD(name, "")
}

// StringD 获取String类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (s MapAny[K]) StringD(name K, defaultVal string) string {
	if v, ok := s[name]; ok {
		if val, err := values.ToStringE(v); err == nil {
			return val
		}
	}
	return defaultVal
}

// StringE 获取String类型键值，如键值存在且能转换为目标类型则返回，否则返回零值和错误提示
func (s MapAny[K]) StringE(key K) (string, error) {
	if v, ok := s[key]; ok {
		val, err := values.ToStringE(v)
		if err == nil {
			return val, nil
		}
		return "", errMapValToType(key, v, "string")
	}
	return "", errMapKeyDoesNotExist(key)
}

// Bool 获取Bool类型键值，如键值存在且能转换为目标类型则返回，否则返回零值
func (s MapAny[K]) Bool(name K) bool {
	return s.BoolD(name, false)
}

// BoolD 获取Bool类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (s MapAny[K]) BoolD(name K, defaultVal bool) bool {
	if v, ok := s[name]; ok {
		if val, err := values.ToBoolE(v); err == nil {
			return val
		}
	}
	return defaultVal
}

// BoolE 获取Bool类型键值，如键值存在且能转换为目标类型则返回，否则返回零值和错误提示
func (s MapAny[K]) BoolE(key K) (bool, error) {
	if v, ok := s[key]; ok {
		val, err := values.ToBoolE(v)
		if err == nil {
			return val, nil
		}
		return false, errMapValToType(key, v, "bool")
	}
	return false, errMapKeyDoesNotExist(key)
}

// Time 获取time.Time类型键值，如键值存在且能转换为目标类型则返回，否则返回零值
//   - 如待转换目标是日期时间字符串未包含时区信息时则使用UTC时区
func (s MapAny[K]) Time(name K) time.Time {
	return s.TimeD(name, time.Time{})
}

// TimeD 获取time.Time类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
//   - 如待转换目标是日期时间字符串未包含时区信息时则使用UTC时区
func (s MapAny[K]) TimeD(name K, defaultVal time.Time) time.Time {
	if v, ok := s[name]; ok {
		if val, err := values.ToTimeE(v); err == nil {
			return val
		}
	}
	return defaultVal
}

// TimeE 获取time.Time类型键值，如键值存在且能转换为目标类型则返回，否则返回零值和错误提示
//   - 如待转换目标是日期时间字符串未包含时区信息时则使用UTC时区
func (s MapAny[K]) TimeE(key K) (time.Time, error) {
	if v, ok := s[key]; ok {
		val, err := values.ToTimeE(v)
		if err == nil {
			return val, nil
		}
		return time.Time{}, errMapValToType(key, v, "time.Time")
	}
	return time.Time{}, errMapKeyDoesNotExist(key)
}

// TimeWith 获取time.Time类型键值，如键值存在且能转换为目标类型则返回，否则返回零值和错误提示
//   - 如待转换目标是日期时间字符串未包含时区信息时则使用location指定的时区
func (s MapAny[K]) TimeWith(key K, location *time.Location) (time.Time, error) {
	if v, ok := s[key]; ok {
		val, err := values.ToTimeWith(v, location)
		if err == nil {
			return val, nil
		}
		return time.Time{}, errMapValToType(key, v, "time.Time")
	}
	return time.Time{}, errMapKeyDoesNotExist(key)
}

// TimeDuration 获取time.Duration类型键值，如键值存在且能转换为目标类型则返回，否则返回零值
func (s MapAny[K]) TimeDuration(name K) time.Duration {
	return s.TimeDurationD(name, 0)
}

// TimeDurationD 获取time.Duration类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (s MapAny[K]) TimeDurationD(name K, defaultVal time.Duration) time.Duration {
	if v, ok := s[name]; ok {
		if val, err := values.ToTimeDurationE(v); err == nil {
			return val
		}
	}
	return defaultVal
}

// TimeDurationE 获取time.Duration类型键值，如键值存在且能转换为目标类型则返回，否则返回零值和错误提示
func (s MapAny[K]) TimeDurationE(key K) (time.Duration, error) {
	if v, ok := s[key]; ok {
		val, err := values.ToTimeDurationE(v)
		if err == nil {
			return val, nil
		}
		return 0, errMapValToType(key, v, "time.Duration")
	}
	return 0, errMapKeyDoesNotExist(key)
}

// SliceAny 获取[]any类型键值，如键值存在且能转换为目标类型则返回，否则返回空切片
func (s MapAny[K]) SliceAny(name K) []any {
	return s.SliceAnyD(name, []any{})
}

// SliceAnyD 获取[]any类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (s MapAny[K]) SliceAnyD(name K, defaultVal []any) []any {
	if v, ok := s[name]; ok {
		if val, err := values.ToSliceAnyE(v); err == nil {
			return val
		}
	}
	return defaultVal
}

// SliceAnyE 获取[]any类型键值，如键值存在且能转换为目标类型则返回，否则返回空切片和错误信息
func (s MapAny[K]) SliceAnyE(name K) ([]any, error) {
	if v, ok := s[name]; ok {
		val, err := values.ToSliceAnyE(v)
		if err == nil {
			return val, nil
		}
		return []any{}, errMapValToType(name, v, "[]any")
	}
	return []any{}, errMapKeyDoesNotExist(name)
}

// SliceString 获取[]string类型键值，如键值存在且能转换为目标类型则返回，否则返回空切片
func (s MapAny[K]) SliceString(name K) []string {
	return s.SliceStringD(name, []string{})
}

// SliceStringD 获取[]string类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (s MapAny[K]) SliceStringD(name K, defaultVal []string) []string {
	if v, ok := s[name]; ok {
		if val, err := values.ToSliceAsE[string](v); err == nil {
			return val
		}
	}
	return defaultVal
}

// SliceStringE 获取[]string类型键值，如键值存在且能转换为目标类型则返回，否则返回空切片和错误信息
func (s MapAny[K]) SliceStringE(name K) ([]string, error) {
	if v, ok := s[name]; ok {
		val, err := values.ToSliceAsE[string](v)
		if err == nil {
			return val, nil
		}
		return []string{}, errMapValToType(name, v, "[]string")
	}
	return []string{}, errMapKeyDoesNotExist(name)
}

// SliceBool 获取[]bool类型键值，如键值存在且能转换为目标类型则返回，否则返回空切片
func (s MapAny[K]) SliceBool(name K) []bool {
	return s.SliceBoolD(name, []bool{})
}

// SliceBoolD 获取[]bool类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (s MapAny[K]) SliceBoolD(name K, defaultVal []bool) []bool {
	if v, ok := s[name]; ok {
		if val, err := values.ToSliceAsE[bool](v); err == nil {
			return val
		}
	}
	return defaultVal
}

// SliceBoolE 获取[]bool类型键值，如键值存在且能转换为目标类型则返回，否则返回空切片和错误信息
func (s MapAny[K]) SliceBoolE(name K) ([]bool, error) {
	if v, ok := s[name]; ok {
		val, err := values.ToSliceAsE[bool](v)
		if err == nil {
			return val, nil
		}
		return []bool{}, errMapValToType(name, v, "[]bool")
	}
	return []bool{}, errMapKeyDoesNotExist(name)
}

// SliceInt 获取[]int类型键值，如键值存在且能转换为目标类型则返回，否则返回空切片
func (s MapAny[K]) SliceInt(name K) []int {
	return s.SliceIntD(name, []int{})
}

// SliceIntD 获取[]int类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (s MapAny[K]) SliceIntD(name K, defaultVal []int) []int {
	if v, ok := s[name]; ok {
		if val, err := values.ToSliceAsE[int](v); err == nil {
			return val
		}
	}
	return defaultVal
}

// SliceIntE 获取[]int类型键值，如键值存在且能转换为目标类型则返回，否则返回空切片和错误信息
func (s MapAny[K]) SliceIntE(name K) ([]int, error) {
	if v, ok := s[name]; ok {
		val, err := values.ToSliceAsE[int](v)
		if err == nil {
			return val, nil
		}
		return []int{}, errMapValToType(name, v, "[]int")
	}
	return []int{}, errMapKeyDoesNotExist(name)
}

// SliceUint 获取[]uint类型键值，如键值存在且能转换为目标类型则返回，否则返回空切片
func (s MapAny[K]) SliceUint(name K) []uint {
	return s.SliceUintD(name, []uint{})
}

// SliceUintD 获取[]uint类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (s MapAny[K]) SliceUintD(name K, defaultVal []uint) []uint {
	if v, ok := s[name]; ok {
		if val, err := values.ToSliceAsE[uint](v); err == nil {
			return val
		}
	}
	return defaultVal
}

// SliceUintE 获取[]uint类型键值，如键值存在且能转换为目标类型则返回，否则返回空切片和错误信息
func (s MapAny[K]) SliceUintE(name K) ([]uint, error) {
	if v, ok := s[name]; ok {
		val, err := values.ToSliceAsE[uint](v)
		if err == nil {
			return val, nil
		}
		return []uint{}, errMapValToType(name, v, "[]uint")
	}
	return []uint{}, errMapKeyDoesNotExist(name)
}

// SliceInt32 获取[]int32类型键值，如键值存在且能转换为目标类型则返回，否则返回空切片
func (s MapAny[K]) SliceInt32(name K) []int32 {
	return s.SliceInt32D(name, []int32{})
}

// SliceInt32D 获取[]int32类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (s MapAny[K]) SliceInt32D(name K, defaultVal []int32) []int32 {
	if v, ok := s[name]; ok {
		if val, err := values.ToSliceAsE[int32](v); err == nil {
			return val
		}
	}
	return defaultVal
}

// SliceInt32E 获取[]int32类型键值，如键值存在且能转换为目标类型则返回，否则返回空切片和错误信息
func (s MapAny[K]) SliceInt32E(name K) ([]int32, error) {
	if v, ok := s[name]; ok {
		val, err := values.ToSliceAsE[int32](v)
		if err == nil {
			return val, nil
		}
		return []int32{}, errMapValToType(name, v, "[]int32")
	}
	return []int32{}, errMapKeyDoesNotExist(name)
}

// SliceUint32 获取[]uint32类型键值，如键值存在且能转换为目标类型则返回，否则返回空切片
func (s MapAny[K]) SliceUint32(name K) []uint32 {
	return s.SliceUint32D(name, []uint32{})
}

// SliceUint32D 获取[]uint32类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (s MapAny[K]) SliceUint32D(name K, defaultVal []uint32) []uint32 {
	if v, ok := s[name]; ok {
		if val, err := values.ToSliceAsE[uint32](v); err == nil {
			return val
		}
	}
	return defaultVal
}

// SliceUint32E 获取[]uint32类型键值，如键值存在且能转换为目标类型则返回，否则返回空切片和错误信息
func (s MapAny[K]) SliceUint32E(name K) ([]uint32, error) {
	if v, ok := s[name]; ok {
		val, err := values.ToSliceAsE[uint32](v)
		if err == nil {
			return val, nil
		}
		return []uint32{}, errMapValToType(name, v, "[]uint32")
	}
	return []uint32{}, errMapKeyDoesNotExist(name)
}

// SliceInt64 获取[]int64类型键值，如键值存在且能转换为目标类型则返回，否则返回空切片
func (s MapAny[K]) SliceInt64(name K) []int64 {
	return s.SliceInt64D(name, []int64{})
}

// SliceInt64D 获取[]int64类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (s MapAny[K]) SliceInt64D(name K, defaultVal []int64) []int64 {
	if v, ok := s[name]; ok {
		if val, err := values.ToSliceAsE[int64](v); err == nil {
			return val
		}
	}
	return defaultVal
}

// SliceInt64E 获取[]int64类型键值，如键值存在且能转换为目标类型则返回，否则返回空切片和错误信息
func (s MapAny[K]) SliceInt64E(name K) ([]int64, error) {
	if v, ok := s[name]; ok {
		val, err := values.ToSliceAsE[int64](v)
		if err == nil {
			return val, nil
		}
		return []int64{}, errMapValToType(name, v, "[]int64")
	}
	return []int64{}, errMapKeyDoesNotExist(name)
}

// SliceUint64 获取[]uint64类型键值，如键值存在且能转换为目标类型则返回，否则返回空切片
func (s MapAny[K]) SliceUint64(name K) []uint64 {
	return s.SliceUint64D(name, []uint64{})
}

// SliceUint64D 获取[]uint64类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (s MapAny[K]) SliceUint64D(name K, defaultVal []uint64) []uint64 {
	if v, ok := s[name]; ok {
		if val, err := values.ToSliceAsE[uint64](v); err == nil {
			return val
		}
	}
	return defaultVal
}

// SliceUint64E 获取[]uint64类型键值，如键值存在且能转换为目标类型则返回，否则返回空切片和错误信息
func (s MapAny[K]) SliceUint64E(name K) ([]uint64, error) {
	if v, ok := s[name]; ok {
		val, err := values.ToSliceAsE[uint64](v)
		if err == nil {
			return val, nil
		}
		return []uint64{}, errMapValToType(name, v, "[]uint64")
	}
	return []uint64{}, errMapKeyDoesNotExist(name)
}

// SliceFloat32 获取[]float32类型键值，如键值存在且能转换为目标类型则返回，否则返回空切片
func (s MapAny[K]) SliceFloat32(name K) []float32 {
	return s.SliceFloat32D(name, []float32{})
}

// SliceFloat32D 获取[]float32类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (s MapAny[K]) SliceFloat32D(name K, defaultVal []float32) []float32 {
	if v, ok := s[name]; ok {
		if val, err := values.ToSliceAsE[float32](v); err == nil {
			return val
		}
	}
	return defaultVal
}

// SliceFloat32E 获取[]float32类型键值，如键值存在且能转换为目标类型则返回，否则返回空切片和错误信息
func (s MapAny[K]) SliceFloat32E(name K) ([]float32, error) {
	if v, ok := s[name]; ok {
		val, err := values.ToSliceAsE[float32](v)
		if err == nil {
			return val, nil
		}
		return []float32{}, errMapValToType(name, v, "[]float32")
	}
	return []float32{}, errMapKeyDoesNotExist(name)
}

// SliceFloat64 获取[]float64类型键值，如键值存在且能转换为目标类型则返回，否则返回空切片
func (s MapAny[K]) SliceFloat64(name K) []float64 {
	return s.SliceFloat64D(name, []float64{})
}

// SliceFloat64D 获取[]float64类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (s MapAny[K]) SliceFloat64D(name K, defaultVal []float64) []float64 {
	if v, ok := s[name]; ok {
		if val, err := values.ToSliceAsE[float64](v); err == nil {
			return val
		}
	}
	return defaultVal
}

// SliceFloat64E 获取[]float64类型键值，如键值存在且能转换为目标类型则返回，否则返回空切片和错误信息
func (s MapAny[K]) SliceFloat64E(name K) ([]float64, error) {
	if v, ok := s[name]; ok {
		val, err := values.ToSliceAsE[float64](v)
		if err == nil {
			return val, nil
		}
		return []float64{}, errMapValToType(name, v, "[]float64")
	}
	return []float64{}, errMapKeyDoesNotExist(name)
}

// SliceTime 获取[]time.Time类型键值，如键值存在且能转换为目标类型则返回，否则返回空切片
func (s MapAny[K]) SliceTime(name K) []time.Time {
	return s.SliceTimeD(name, []time.Time{})
}

// SliceTimeD 获取[]time.Time类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (s MapAny[K]) SliceTimeD(name K, defaultVal []time.Time) []time.Time {
	if v, ok := s[name]; ok {
		if val, err := values.ToSliceAsE[time.Time](v); err == nil {
			return val
		}
	}
	return defaultVal
}

// SliceTimeE 获取[]time.Time类型键值，如键值存在且能转换为目标类型则返回，否则返回空切片和错误信息
func (s MapAny[K]) SliceTimeE(name K) ([]time.Time, error) {
	if v, ok := s[name]; ok {
		val, err := values.ToSliceAsE[time.Time](v)
		if err == nil {
			return val, nil
		}
		return []time.Time{}, errMapValToType(name, v, "[]time.Time")
	}
	return []time.Time{}, errMapKeyDoesNotExist(name)
}

// SliceTimeDuration 获取[]time.Duration类型键值，如键值存在且能转换为目标类型则返回，否则返回空切片
func (s MapAny[K]) SliceTimeDuration(name K) []time.Duration {
	return s.SliceTimeDurationD(name, []time.Duration{})
}

// SliceTimeDurationD 获取[]time.Duration类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (s MapAny[K]) SliceTimeDurationD(name K, defaultVal []time.Duration) []time.Duration {
	if v, ok := s[name]; ok {
		if val, err := values.ToSliceAsE[time.Duration](v); err == nil {
			return val
		}
	}
	return defaultVal
}

// SliceTimeDurationE 获取[]time.Duration类型键值，如键值存在且能转换为目标类型则返回，否则返回空切片和错误信息
func (s MapAny[K]) SliceTimeDurationE(name K) ([]time.Duration, error) {
	if v, ok := s[name]; ok {
		val, err := values.ToSliceAsE[time.Duration](v)
		if err == nil {
			return val, nil
		}
		return []time.Duration{}, errMapValToType(name, v, "[]time.Duration")
	}
	return []time.Duration{}, errMapKeyDoesNotExist(name)
}

// MapAny 获取map[string]any类型键值，如键值存在且能转换为目标类型则返回，否则返回空map
func (s MapAny[K]) MapAny(name K) map[string]any {
	return s.MapAnyD(name, map[string]any{})
}

// MapAnyD 获取map[string]any类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (s MapAny[K]) MapAnyD(name K, defaultVal map[string]any) map[string]any {
	if v, ok := s[name]; ok {
		if val, err := values.ToMapAnyE[string](v); err == nil {
			return val
		}
	}
	return defaultVal
}

// MapAnyE 获取map[string]any类型键值，如键值存在且能转换为目标类型则返回，否则返回空map和错误信息
func (s MapAny[K]) MapAnyE(name K) (map[string]any, error) {
	if v, ok := s[name]; ok {
		val, err := values.ToMapAnyE[string](v)
		if err == nil {
			return val, nil
		}
		return map[string]any{}, errMapValToType(name, v, "map[string]any")
	}
	return map[string]any{}, errMapKeyDoesNotExist(name)
}

// MapString 获取map[string]string类型键值，如键值存在且能转换为目标类型则返回，否则返回空map
func (s MapAny[K]) MapString(name K) map[string]string {
	return s.MapStringD(name, map[string]string{})
}

// MapStringD 获取map[string]string类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (s MapAny[K]) MapStringD(name K, defaultVal map[string]string) map[string]string {
	if v, ok := s[name]; ok {
		if val, err := values.ToMapAsE[string, string](v); err == nil {
			return val
		}
	}
	return defaultVal
}

// MapStringE 获取map[string]string类型键值，如键值存在且能转换为目标类型则返回，否则返回空map和错误信息
func (s MapAny[K]) MapStringE(name K) (map[string]string, error) {
	if v, ok := s[name]; ok {
		val, err := values.ToMapAsE[string, string](v)
		if err == nil {
			return val, nil
		}
		return map[string]string{}, errMapValToType(name, v, "map[string]string")
	}
	return map[string]string{}, errMapKeyDoesNotExist(name)
}

// MapBool 获取map[string]bool类型键值，如键值存在且能转换为目标类型则返回，否则返回空map
func (s MapAny[K]) MapBool(name K) map[string]bool {
	return s.MapBoolgD(name, map[string]bool{})
}

// MapBoolgD 获取map[string]bool类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (s MapAny[K]) MapBoolgD(name K, defaultVal map[string]bool) map[string]bool {
	if v, ok := s[name]; ok {
		if val, err := values.ToMapAsE[string, bool](v); err == nil {
			return val
		}
	}
	return defaultVal
}

// MapBoolE 获取map[string]bool类型键值，如键值存在且能转换为目标类型则返回，否则返回空map和错误信息
func (s MapAny[K]) MapBoolE(name K) (map[string]bool, error) {
	if v, ok := s[name]; ok {
		val, err := values.ToMapAsE[string, bool](v)
		if err == nil {
			return val, nil
		}
		return map[string]bool{}, errMapValToType(name, v, "map[string]bool")
	}
	return map[string]bool{}, errMapKeyDoesNotExist(name)
}

// MapInt 获取map[string]int类型键值，如键值存在且能转换为目标类型则返回，否则返回空map
func (s MapAny[K]) MapInt(name K) map[string]int {
	return s.MapIntD(name, map[string]int{})
}

// MapIntD 获取map[string]int类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (s MapAny[K]) MapIntD(name K, defaultVal map[string]int) map[string]int {
	if v, ok := s[name]; ok {
		if val, err := values.ToMapAsE[string, int](v); err == nil {
			return val
		}
	}
	return defaultVal
}

// MapIntE 获取map[string]int类型键值，如键值存在且能转换为目标类型则返回，否则返回空map和错误信息
func (s MapAny[K]) MapIntE(name K) (map[string]int, error) {
	if v, ok := s[name]; ok {
		val, err := values.ToMapAsE[string, int](v)
		if err == nil {
			return val, nil
		}
		return map[string]int{}, errMapValToType(name, v, "map[string]int")
	}
	return map[string]int{}, errMapKeyDoesNotExist(name)
}

// MapUint 获取map[string]uint类型键值，如键值存在且能转换为目标类型则返回，否则返回空map
func (s MapAny[K]) MapUint(name K) map[string]uint {
	return s.MapUintD(name, map[string]uint{})
}

// MapUintD 获取map[string]uint类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (s MapAny[K]) MapUintD(name K, defaultVal map[string]uint) map[string]uint {
	if v, ok := s[name]; ok {
		if val, err := values.ToMapAsE[string, uint](v); err == nil {
			return val
		}
	}
	return defaultVal
}

// MapUintE 获取map[string]uint类型键值，如键值存在且能转换为目标类型则返回，否则返回空map和错误信息
func (s MapAny[K]) MapUintE(name K) (map[string]uint, error) {
	if v, ok := s[name]; ok {
		val, err := values.ToMapAsE[string, uint](v)
		if err == nil {
			return val, nil
		}
		return map[string]uint{}, errMapValToType(name, v, "map[string]uint")
	}
	return map[string]uint{}, errMapKeyDoesNotExist(name)
}

// MapInt32 获取map[string]int32类型键值，如键值存在且能转换为目标类型则返回，否则返回空map
func (s MapAny[K]) MapInt32(name K) map[string]int32 {
	return s.MapInt32D(name, map[string]int32{})
}

// MapInt32D 获取map[string]int32类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (s MapAny[K]) MapInt32D(name K, defaultVal map[string]int32) map[string]int32 {
	if v, ok := s[name]; ok {
		if val, err := values.ToMapAsE[string, int32](v); err == nil {
			return val
		}
	}
	return defaultVal
}

// MapInt32E 获取map[string]int32类型键值，如键值存在且能转换为目标类型则返回，否则返回空map和错误信息
func (s MapAny[K]) MapInt32E(name K) (map[string]int32, error) {
	if v, ok := s[name]; ok {
		val, err := values.ToMapAsE[string, int32](v)
		if err == nil {
			return val, nil
		}
		return map[string]int32{}, errMapValToType(name, v, "map[string]int32")
	}
	return map[string]int32{}, errMapKeyDoesNotExist(name)
}

// MapInt64 获取map[string]int64类型键值，如键值存在且能转换为目标类型则返回，否则返回空map
func (s MapAny[K]) MapInt64(name K) map[string]int64 {
	return s.MapInt64D(name, map[string]int64{})
}

// MapInt64D 获取map[string]int64类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (s MapAny[K]) MapInt64D(name K, defaultVal map[string]int64) map[string]int64 {
	if v, ok := s[name]; ok {
		if val, err := values.ToMapAsE[string, int64](v); err == nil {
			return val
		}
	}
	return defaultVal
}

// MapInt64E 获取map[string]int64类型键值，如键值存在且能转换为目标类型则返回，否则返回空map和错误信息
func (s MapAny[K]) MapInt64E(name K) (map[string]int64, error) {
	if v, ok := s[name]; ok {
		val, err := values.ToMapAsE[string, int64](v)
		if err == nil {
			return val, nil
		}
		return map[string]int64{}, errMapValToType(name, v, "map[string]int64")
	}
	return map[string]int64{}, errMapKeyDoesNotExist(name)
}

// MapUint32 获取map[string]uint32类型键值，如键值存在且能转换为目标类型则返回，否则返回空map
func (s MapAny[K]) MapUint32(name K) map[string]uint32 {
	return s.MapUint32D(name, map[string]uint32{})
}

// MapUint32D 获取map[string]uint32类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (s MapAny[K]) MapUint32D(name K, defaultVal map[string]uint32) map[string]uint32 {
	if v, ok := s[name]; ok {
		if val, err := values.ToMapAsE[string, uint32](v); err == nil {
			return val
		}
	}
	return defaultVal
}

// MapUint32E 获取map[string]uint32类型键值，如键值存在且能转换为目标类型则返回，否则返回空map和错误信息
func (s MapAny[K]) MapUint32E(name K) (map[string]uint32, error) {
	if v, ok := s[name]; ok {
		val, err := values.ToMapAsE[string, uint32](v)
		if err == nil {
			return val, nil
		}
		return map[string]uint32{}, errMapValToType(name, v, "map[string]uint32")
	}
	return map[string]uint32{}, errMapKeyDoesNotExist(name)
}

// MapUint64 获取map[string]uint64类型键值，如键值存在且能转换为目标类型则返回，否则返回空map
func (s MapAny[K]) MapUint64(name K) map[string]uint64 {
	return s.MapUint64D(name, map[string]uint64{})
}

// MapUint64D 获取map[string]uint64类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (s MapAny[K]) MapUint64D(name K, defaultVal map[string]uint64) map[string]uint64 {
	if v, ok := s[name]; ok {
		if val, err := values.ToMapAsE[string, uint64](v); err == nil {
			return val
		}
	}
	return defaultVal
}

// MapUint64E 获取map[string]uint64类型键值，如键值存在且能转换为目标类型则返回，否则返回空map和错误信息
func (s MapAny[K]) MapUint64E(name K) (map[string]uint64, error) {
	if v, ok := s[name]; ok {
		val, err := values.ToMapAsE[string, uint64](v)
		if err == nil {
			return val, nil
		}
		return map[string]uint64{}, errMapValToType(name, v, "map[string]uint64")
	}
	return map[string]uint64{}, errMapKeyDoesNotExist(name)
}

// MapFloat32 获取map[string]float32类型键值，如键值存在且能转换为目标类型则返回，否则返回空map
func (s MapAny[K]) MapFloat32(name K) map[string]float32 {
	return s.MapFloat32D(name, map[string]float32{})
}

// MapFloat32D 获取map[string]float32类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (s MapAny[K]) MapFloat32D(name K, defaultVal map[string]float32) map[string]float32 {
	if v, ok := s[name]; ok {
		if val, err := values.ToMapAsE[string, float32](v); err == nil {
			return val
		}
	}
	return defaultVal
}

// MapFloat32E 获取map[string]float32类型键值，如键值存在且能转换为目标类型则返回，否则返回空map和错误信息
func (s MapAny[K]) MapFloat32E(name K) (map[string]float32, error) {
	if v, ok := s[name]; ok {
		val, err := values.ToMapAsE[string, float32](v)
		if err == nil {
			return val, nil
		}
		return map[string]float32{}, errMapValToType(name, v, "map[string]float32")
	}
	return map[string]float32{}, errMapKeyDoesNotExist(name)
}

// MapFloat64 获取map[string]float64类型键值，如键值存在且能转换为目标类型则返回，否则返回空map
func (s MapAny[K]) MapFloat64(name K) map[string]float64 {
	return s.MapFloat64D(name, map[string]float64{})
}

// MapFloat64D 获取map[string]float64类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (s MapAny[K]) MapFloat64D(name K, defaultVal map[string]float64) map[string]float64 {
	if v, ok := s[name]; ok {
		if val, err := values.ToMapAsE[string, float64](v); err == nil {
			return val
		}
	}
	return defaultVal
}

// MapFloat64E 获取map[string]float64类型键值，如键值存在且能转换为目标类型则返回，否则返回空map和错误信息
func (s MapAny[K]) MapFloat64E(name K) (map[string]float64, error) {
	if v, ok := s[name]; ok {
		val, err := values.ToMapAsE[string, float64](v)
		if err == nil {
			return val, nil
		}
		return map[string]float64{}, errMapValToType(name, v, "map[string]float64")
	}
	return map[string]float64{}, errMapKeyDoesNotExist(name)
}

// MapTime 获取map[string]time.Time类型键值，如键值存在且能转换为目标类型则返回，否则返回空map
func (s MapAny[K]) MapTime(name K) map[string]time.Time {
	return s.MapTimeD(name, map[string]time.Time{})
}

// MapTimeD 获取map[string]time.Time类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (s MapAny[K]) MapTimeD(name K, defaultVal map[string]time.Time) map[string]time.Time {
	if v, ok := s[name]; ok {
		if val, err := values.ToMapAsE[string, time.Time](v); err == nil {
			return val
		}
	}
	return defaultVal
}

// MapTimeE 获取map[string]time.Time类型键值，如键值存在且能转换为目标类型则返回，否则返回空map和错误信息
func (s MapAny[K]) MapTimeE(name K) (map[string]time.Time, error) {
	if v, ok := s[name]; ok {
		val, err := values.ToMapAsE[string, time.Time](v)
		if err == nil {
			return val, nil
		}
		return map[string]time.Time{}, errMapValToType(name, v, "map[string]time.Time")
	}
	return map[string]time.Time{}, errMapKeyDoesNotExist(name)
}

// MapTimeDuration 获取map[string]time.Duration类型键值，如键值存在且能转换为目标类型则返回，否则返回空map
func (s MapAny[K]) MapTimeDuration(name K) map[string]time.Duration {
	return s.MapTimeDurationD(name, map[string]time.Duration{})
}

// MapTimeDurationD 获取map[string]time.Duration类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (s MapAny[K]) MapTimeDurationD(name K, defaultVal map[string]time.Duration) map[string]time.Duration {
	if v, ok := s[name]; ok {
		if val, err := values.ToMapAsE[string, time.Duration](v); err == nil {
			return val
		}
	}
	return defaultVal
}

// MapTimeDurationE 获取map[string]time.Duration类型键值，如键值存在且能转换为目标类型则返回，否则返回空map和错误信息
func (s MapAny[K]) MapTimeDurationE(name K) (map[string]time.Duration, error) {
	if v, ok := s[name]; ok {
		val, err := values.ToMapAsE[string, time.Duration](v)
		if err == nil {
			return val, nil
		}
		return map[string]time.Duration{}, errMapValToType(name, v, "map[string]time.Duration")
	}
	return map[string]time.Duration{}, errMapKeyDoesNotExist(name)
}

// Scan 通过序列化扫描到指定对象
func (s MapAny[K]) Scan(name K, refVal any) error {
	if _, ok := s[name]; !ok {
		return fmt.Errorf("MapAny[%T] Scan(%v,refVal) name does not exist", name, name)
	}
	if refVal == nil {
		return fmt.Errorf("MapAny[%T] Scan(%v,refVal) refVal can not a nil pointer", name, name)
	}
	if bytes, err := jsoner.Marshal(s[name]); err != nil {
		return fmt.Errorf("MapAny[%T] Scan(%v,refVal) json Marshal error: %s", name, name, err.Error())
	} else if err := jsoner.Unmarshal(bytes, refVal); err != nil {
		return fmt.Errorf("MapAny[%T] Scan(%v,refVal) json Unmarshal error: %s", name, name, err.Error())
	} else {
		return nil
	}
}

// Size 获取数据集大小
func (s MapAny[K]) Size() int {
	return len(s)
}

// Clear 清空所有数据
func (s MapAny[K]) Clear() {
	for k := range s {
		delete(s, k)
	}
}

// Collects 取得数据集
func (s MapAny[K]) Collects() (collects map[K]any) {
	n := make(map[K]any, len(s))
	for k, v := range s {
		n[k] = v
	}
	return n
}

// Keys 取得map键 数据集 []K
func (s MapAny[K]) Keys() (keys []K) {
	keys = make([]K, len(s))
	i := 0
	for key := range s {
		keys[i] = key
		i++
	}
	return keys
}

// Values 取得map值 数据集 []any
func (s MapAny[K]) Values() (values []any) {
	values = make([]any, len(s))
	i := 0
	for _, val := range s {
		values[i] = val
		i++
	}
	return values
}

// Iter map[K]V 元素迭代器
//   - for k,v:=range s.Iter(){}
//   - 推荐 for k,v:=range H(){} 替换 s.Iter
//   - 推荐 for k:=range H(){} 替换 s.IterKeys
//   - 推荐 for _,v:=range H(){} 替换 s.IterValues
func (s MapAny[K]) Iter() iter.Seq2[K, any] {
	return func(yield func(key K, val any) bool) {
		for k, v := range s {
			if !yield(k, v) {
				return
			}
		}
	}
}

// IterKeys map[K]V key迭代器
//   - for key:=range s.IterKeys(){}
//   - 推荐 for k:=range H(){} 替换 s.IterKeys
func (s MapAny[K]) IterKeys() iter.Seq[K] {
	return func(yield func(key K) bool) {
		for k := range s {
			if !yield(k) {
				return
			}
		}
	}
}

// IterValues map[K]V value 迭代器
//   - for val:=range s.IterValues(){}
//   - 推荐 for _,v:=range H(){} 替换 s.IterValues
func (s MapAny[K]) IterValues() iter.Seq[any] {
	return func(yield func(val any) bool) {
		for _, v := range s {
			if !yield(v) {
				return
			}
		}
	}
}
